import {
  getNewCartGoods,
  findCart,
  mergeCart,
  insertCart,
  deleteCart,
  updateCart,
  checkAllCart
} from '@/api/cart'
// 购物车状态
export default {
  namespaced: true,
  state() {
    return {
      list: []
    }
  },
  getters: {
    // 有效商品列表
    validList(state) {
      return state.list.filter((item) => item.stock > 0 && item.isEffective)
    },
    // 有效商品件数
    validTotal(state, getters) {
      // return getters.validList.reduce((total, item) => (total += item.count), 0)
      return getters.validList.length
    },
    // 有效商品总金额
    validAmount(state, getters) {
      return getters.validList
        .reduce((total, item) => total + item.nowPrice * item.count, 0)
        .toFixed(2)
    },
    // 无效商品列表
    invalidList(state) {
      return state.list.filter((item) => !(item.stock > 0 && item.isEffective))
    },
    // 选中商品列表
    selectedList(state, getters) {
      return getters.validList.filter((item) => item.selected)
    },
    // 选中商品件数
    selectedTotal(state, getters) {
      // return getters.selectedList.reduce((p, c) => p + c.count, 0)
      return getters.selectedList.length
    },
    // 选中商品总金额
    selectedAmmount(state, getters) {
      return getters.selectedList
        .reduce((p, c) => p + c.nowPrice * c.count, 0)
        .toFixed(2)
    },
    // 是否全选
    isCheckAll(state, getters) {
      return (
        getters.validList.length === getters.selectedList.length &&
        getters.selectedList.length !== 0
      )
    }
  },
  // 本地：id skuId name picture price nowPrice count attrsText selected stock isEffective
  // 线上：比上面多 isCollect 有用 discount 无用 两项项信息
  mutations: {
    // 加入购物车
    insertCart(state, payLoad) {
      // 考虑两种情况
      // 情况1:已经添加过商品（skuid已存在），是数量的累加
      // 情况2:没有添加过商品，就添加到列表前
      const index = state.list.findIndex((item) => item.skuId === payLoad.skuId)
      if (index > -1) {
        state.list[index].count += payLoad.count
      } else {
        state.list.unshift(payLoad)
      }
    },
    // 修改购物车商品
    updateCart(state, goods) {
      // 1.goods必须有skuid，才能找到对应的商品信息
      const updateGoods = state.list.find((item) => item.skuId === goods.skuId)
      for (const key in goods) {
        if (
          goods[key] !== null &&
          goods[key] !== undefined &&
          goods[key] !== ''
        ) {
          updateGoods[key] = goods[key]
        }
      }
    },
    // 删除购物车商品
    deleteCart(state, skuId) {
      const index = state.list.findIndex((item) => item.skuId === skuId)
      state.list.splice(index, 1)
    },
    // 设置购物车列表
    setCartList(state, list) {
      state.list = list
    }
  },
  actions: {
    // 加入购物车
    insertCart(store, goods) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 已登录
          insertCart({ skuId: goods.skuId, count: goods.count }).then(
            async () => {
              // 加入购物车成功后，直接获取并更新最新列表
              const { result } = await findCart()
              store.commit('setCartList', result)
              resolve()
            }
          )
        } else {
          // 未登录
          store.commit('insertCart', goods)
          resolve()
        }
      })
    },
    // 获取购物车列表
    findCartList(store) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // todo登录
          findCart().then((data) => {
            store.commit('setCartList', data.result)
            resolve()
          })
        } else {
          // 本地
          // 未登录，也要同步最新商品信息（价格，库存。。。）
          store.state.list.forEach(async (item) => {
            const { result } = await getNewCartGoods(item.skuId)
            store.commit('updateCart', { ...result, skuId: item.skuId })
          })
          resolve('购物车信息同步成功-本地')
        }
      })
    },
    // 修改购物车商品
    updateCart(store, goods) {
      // goods中，必须有skuid，其他想修改的属性，selected count
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 登录
          updateCart(goods)
            .then(() => {
              return findCart()
            })
            .then((data) => {
              store.commit('setCartList', data.result)
              resolve()
            })
        } else {
          // 本地
          store.commit('updateCart', goods)
          resolve()
        }
      })
    },
    // 修改sku规格函数
    updateCartSku(store, { oldSkuId, newSku }) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // todo登录
          // 1.获取原先商品的数量
          // 2.删除原先商品
          // 3.获取修改的skuid和原先商品数量，做一个加入购物车操作
          // 4.更新列表
          const oldGoods = store.state.list.find(
            (item) => item.skuId === oldSkuId
          )
          deleteCart([oldSkuId])
            .then(() => {
              return insertCart({ skuId: newSku.skuId, count: oldGoods.count })
            })
            .then(() => {
              return findCart()
            })
            .then((data) => {
              store.commit('setCartList', data.result)
              resolve()
            })
        } else {
          // 本地
          // 但你修改了sku的时候其实skuid需要更改，相当于把原来的信息移出，创建一条新的商品信息
          // 1.获取旧的商品信息
          const oldGoods = store.state.list.find(
            (item) => item.skuId === oldSkuId
          )
          // 2.删除旧的商品
          store.commit('deleteCart', oldSkuId)
          // 3.合并一条新的商品信息
          const { skuId, price: nowPrice, inventory: stock, attrsText } = newSku
          const newGoods = { ...oldGoods, skuId, nowPrice, stock, attrsText }
          // 4.插入即可
          store.commit('insertCart', newGoods)
        }
      })
    },
    // 做有效商品的全选&反选
    checkAllCart(store, selected) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 登录
          const ids = store.getters.validList.map((item) => item.skuId)
          checkAllCart({ selected, ids })
            .then(() => {
              return findCart()
            })
            .then((data) => {
              store.commit('setCartList', data.result)
              resolve()
            })
        } else {
          // 本地
          // 1.获取有效商品列表，遍历去调用修改mutations即可
          store.getters.validList.forEach((item) => {
            store.commit('updateCart', {
              skuId: item.skuId,
              selected: selected
            })
          })
          resolve()
        }
      })
    },
    // 删除购物车
    deleteCart(store, skuId) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 已登录
          deleteCart([skuId]).then(async () => {
            const { result } = await findCart()
            store.commit('setCartList', result)
            resolve()
          })
        } else {
          // 本地
          store.commit('deleteCart', skuId)
          resolve()
        }
      })
    },

    // 批量删除选中商品
    batchDeleteCart(store, isInvalid) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 登录
          // 得到需要删除的商品列表，（失效，选中）的skuid集合
          const ids = store.getters[
            isInvalid ? 'invalidList' : 'selectedList'
          ].map((item) => item.skuId)
          deleteCart(ids)
            .then(() => {
              return findCart()
            })
            .then((data) => {
              store.commit('setCartList', data.result)
              resolve()
            })
        } else {
          // 本地
          // 1.获取选中商品列表，进行遍历调用deleteCart mutations函数
          store.getters[isInvalid ? 'invalidList' : 'selectedList'].forEach(
            (item) => {
              store.commit('deleteCart', item.skuId)
            }
          )
          resolve()
        }
      })
    },

    // 合并本地购物车
    async mergeLocalCart(store) {
      // 合并购物车
      const data = store.state.list.map(({ skuId, selected, count }) => ({
        skuId,
        selected,
        count
      }))
      await mergeCart(data)
      // 获取购物车列表
      const { result } = await findCart()
      store.commit('setCartList', result)
    }
  }
}
